// gcc -o all2 all2.c && all2.exe#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>
#include <stdio.h>
#define HEADER 0xAA
#define FOOTER 0x2F

typedef struct {
    uint8_t* data;
    size_t length;
} Packet;

typedef struct {
    Packet* packets;
    size_t count;
} PacketList;

typedef struct {
    uint8_t header;         // 包头
    uint8_t length;         // 长度
    uint8_t command;        // 命令
    char sign_unit[8];      // 正负+单位
    uint8_t decimal;        // 小数位
    float net_weight;       // 净重
    char stability[16];     // 稳定状态
    float tare;             // 皮重
    uint8_t footer;         // 包尾
    // 基础字段
} ParsedPacket;

// 十六进制字符串转字节数组
uint8_t* hex_str_to_bytes(const char* hex_str, size_t* out_len) {
    char* tmp = strdup(hex_str);
    char* token = strtok(tmp, " ");
    uint8_t* bytes = malloc(strlen(hex_str)/3 + 1);
    size_t count = 0;

    while (token != NULL) {
        bytes[count++] = (uint8_t)strtol(token, NULL, 16);
        token = strtok(NULL, " ");
    }
    
    *out_len = count;
    free(tmp);
    return bytes;
}

// 数据包分割（改进版）
PacketList split_packets(const uint8_t* data, size_t len) {
    PacketList list = {NULL, 0};
    size_t start = 0;
    int in_packet = 0;

    for (size_t i = 0; i < len; ++i) {
        if (data[i] == HEADER && !in_packet) {
            start = i;
            in_packet = 1;
        } else if (data[i] == FOOTER && in_packet) {
            size_t pkt_len = i - start + 1;
            list.packets = realloc(list.packets, (list.count+1)*sizeof(Packet));
            list.packets[list.count].data = malloc(pkt_len);
            memcpy(list.packets[list.count].data, data+start, pkt_len);
            list.packets[list.count].length = pkt_len;
            list.count++;
            in_packet = 0;
        }
    }
    return list;
}

// 解析单个数据包（支持多命令）
ParsedPacket parse_packet(const uint8_t* data, size_t len) {
    ParsedPacket result = {0};
    
    // 基础校验
    if (len < 5 || data[0] != HEADER || data[len-1] != FOOTER) {
        printf("无效数据包\n");
        return result;
    }

    // 通用字段解析
    result.header = data[0];
    result.length = data[1];
    result.command = data[2];
    result.footer = data[len-1];

    // 按命令类型处理
    switch (result.command) {
        case 0x20: { // 重量数据包
            if (len < 15) break;

            // 符号和单位
            switch (data[3]) {
                case 0x81: strcpy(result.sign_unit, "+KG"); break;
                case 0x01: strcpy(result.sign_unit, "-KG"); break;
                default:   strcpy(result.sign_unit, "未知");
            }


            // 小数位
            result.decimal = data[4];

                // 解析净重（大端序）
            // uint32_t net_weight_raw = (data[5] << 24) | (data[6] << 16) | (data[7] << 8) | data[8];
            // result->net_weight = (double)net_weight_raw / pow(10, result->decimal);

            // 净重（4字节大端）
            uint32_t net_weight_raw = (data[5] << 24) | (data[6] << 16) | (data[7] << 8) | data[8];
            result.net_weight = net_weight_raw / pow(10, result.decimal);

            // 稳定状态
            strcpy(result.stability, (data[9] == 0x0A) ? "稳定" : "不稳定");

            // 皮重（3字节）
            uint32_t tare = (data[10] << 16) | (data[11] << 8) | data[12];
            result.tare = tare / pow(10, result.decimal);
            break;
        }
        case 0x27: { // 新命令类型示例
            if (len < 16) break;

            // 解析示例字段（需根据实际协议调整）
            result.decimal = data[4];
            
            // 假设净重从第10字节开始（示例）
            uint32_t net = (data[10] << 24) | (data[11] << 16) | (data[12] << 8) | data[13];
            result.net_weight = net / pow(10, result.decimal);
            break;
        }
        default:
            printf("未知命令: 0x%02X\n", result.command);
    }

    return result;
}

void print_packet(const ParsedPacket* pkt) {
    printf("包头: 0x%02X\n", pkt->header);
    printf("长度: 0x%02X\n", pkt->length);
    printf("命令: 0x%02X\n", pkt->command);
    
    if (pkt->command == 0x20) {
        printf("单位: %s\n", pkt->sign_unit);
        printf("小数位: %d\n", pkt->decimal);
        printf("净重: %.*f\n", pkt->decimal, pkt->net_weight);
        printf("稳定状态: %s\n", pkt->stability);
        printf("皮重: %.*f\n", pkt->decimal, pkt->tare);
    } else if (pkt->command == 0x27) {
        printf("净重: %.*f\n", pkt->decimal, pkt->net_weight);
    }
    
    printf("包尾: 0x%02X\n\n", pkt->footer);
}

int main() {
    const char* hex_str = "AA 0B 20 01 03 00 00 00 19 0A 00 00 00 FC 2F AA 0B 20 81 03 00 00 01 2C 0A 00 00 00 90 2F AA 0B 20 81 03 00 00 02 08 0A 00 00 00 6D 2F  ";

    // 转换十六进制字符串
    size_t data_len;
    uint8_t* byte_data = hex_str_to_bytes(hex_str, &data_len);

    // 分割数据包
    PacketList packets = split_packets(byte_data, data_len);

    // 解析并打印结果
    for (size_t i = 0; i < packets.count; ++i) {
        printf("==== 数据包 %zu ====\n", i+1);
        ParsedPacket pkt = parse_packet(packets.packets[i].data, packets.packets[i].length);
        print_packet(&pkt);
    }

    // 释放内存
    free(byte_data);
    for (size_t i = 0; i < packets.count; ++i) {
        free(packets.packets[i].data);
    }
    free(packets.packets);

    return 0;
}

// gcc -o all_uart E:\D133EBS\UART_ALL\application\rt-thread\helloworld\text\py\all_uart.c && E:\D133EBS\UART_ALL\application\rt-thread\helloworld\text\py\all_uart.exe